מבני נתונים הגבלת אחריות פרק - 1 אלגוריתמי מיון ואנליזה אסימפטוטית. מיון בועות Sort Bubble מאת : סשה גולדשטיין,

Transcript

1 009 מבני נתונים סיכום למבחן, יולי מאת : סשה גולדשטיין, 7:50, עדכון אחרון : בשעה הגבלת אחריות הסיכום להלן הוא האינטרפרטציה שלי של החומר, שממש לא חייבת להיות נכונה או מייצגת את זו של הסגל. בכל זאת, אני מניח שהרשימות להלן שמבוססות על סיכומי שיעורים ותרגולים, וכן על המצגות של התרגולים, הפתרונות של התרגילים ומקורות חיצוניים יכולות להיות לעזר בהכנה למבחן. מה שאני מנסה להגיד כאן הוא: השימוש בסיכום הזה הוא על אחריותכם בלבד. אל תאשימו אף אחד אח"כ אם במבחן שאלו משהו שלא היה בסיכום, או שמופיע בסיכום עם טעות. דרך אגב, מסיבה זו בדיוק אשמח מאוד אם תעבירו אליי הערות, תיקונים או כל דבר אחר בנוגע לרשימות האלה.)sashag@cs( פרק - אלגוריתמי מיון ואנליזה אסימפטוטית מיון בועות Sort Bubble נתונים איברים למיון בתוך מערך. נפעפע את האיבר הגדול ביותר לחלק של המערך שעוד לא מוין. לאחר שלב k יש לנו n k איברים שטרם מויינו, ו- k איברים בצידו הימני של המערך שכבר ממוינים )בסדר עולה(. BUBBLE SORT A n for i to n for j to n i if A j > A j + ten swap A j, A j + ניתוח זמן הריצה של האלגוריתם משמעותו חישוב מספר הצעדים הבסיסיים שהאלגוריתם מבצע עבור קלט בגודל n. אם אנו יודעים את המחיר )הקבוע( של הצעדים הבסיסיים, נוכל להסיק את התנהגות זמן הריצה כפונקציה של.T n ונסמן כאן,n הגדרה: צעדים בסיסיים: השמה, השוואה, החלפה, קידום משתנה )כולם בעלות של (. נחשב את זמן הריצה בהנחה שפעולת ההחלפה )כמו כל שאר הפעולות( עולה יחידת זמן אחת: n n i T n = i= j = = 3 n n n n n i n = + 3 = n + 3 n i i= i= j = i= 3n n = n + לעומת זאת, אם למשל נבחר להתבונן בפעולת ההחלפה כפעולה שעולה 4 יחידות זמן, נקבל:

2 n n i T n = + 6 i= j = = = 3n n לכאורה קיבלנו שני ביטויים שונים לחלוטין, אך מה כאן העיקר ומה הטפל? האם יש משמעות לתמחור הצעדים הבסיסיים כאשר מעניינת אותנו בעיקר ההתנהגות האסימפטוטית של הקלט )כאשר n(? כדי לנתח אלגוריתמים ללא תלות במערכת שעליה הן רצות )שמשפיעה על תמחור הצעדים הבסיסיים(, נרצה רק להבחין בין הפעולות הבסיסיות שלוקחות זמן קבוע לבין כל דבר אחר, כגון לולאות למשל, שזמן הביצוע שלו תלוי בגודל הקלט. אנליזה אסיפמטוטית הגדרה: f n = O g n אם cg(n) c > 0, n 0 N n > n 0, f n הגדרה: f n = Ω g n אם cg(n) c > 0, n 0 N n > n 0, f n הגדרה: f n = Θ g n אם f n = O g n וגם f n = Ω g n li n f n f n = o g n אם = 0 g n הגדרה: טענה : הסימונים האסימפטוטיים הם טרנזיטיביים, למשל: f n = Ω g n, g n = Ω n f n = Ω n הוכחה: מיידית מההגדרות. הערה: בדרך כלל אנו עוסקים בפונקציות חיוביות. אם הפונקציות אינן חיוביות, כמעט לא ניתן לומר דבר על היחסים ביניהן. למשל ייתכן שאם נסכום שתי פונקציות )שהאחת שלילית והאחרת חיובית( הן יבטלו זו את זו, ולעומת זאת בניתוח אסימפטוטי רגיל אנו לרוב מניחים שסכום של שתי פונקציות הוא לפחות Θ של כל אחת מהן בנפרד. טענה : אם f n = Θ g n + n, g n = o n אזי ) n f n = Θ( הוכחה: ר' פתרון תרגיל, מההגדרות. דוגמה לניתוח סיבוכיות באמצעות אנליזה אסימפטוטית נחזור למיון הבועות שראינו קודם. ראינו כבר ש- אנו רוצים להשתמש בנוטציה אסימפטוטית. וכעת אנו רוצים להראות שקיים n 0 המקיים.T n n n > n 0 נציב.T n = 3 n n טענה 3: סיבוכיות זמן הריצה של מיון בועות היא Θ. n 3 n n n n n n 0 הוכחה: נתבונן הפוך נבחר קבוע = c באי שוויון: כלומר אכן עבור = 0 n מתקיים ) T n = Ω(n ובאופן סימטרי מראים T n = O n ולכן ).T n = Θ(n

3 כללי אצבע לגבי התנהגות אסימפטוטית: קבועים כפליים לא משנים, למשל ) f n = O 4n f n = O(n וזאת מאחר שמותר לנו לבחור קבוע c גדול ככל שנרצה, או קטן ככל שנרצה. f n = Θ n f n = Θ g n + n, g n = o n אזי טענה : אם f n = O g n ואפילו טענה :4 אם f n = n d, g n = c n )כאשר )c >, d >, d N אזי f n = o g n f n = o g n f n = O g n ואפילו טענה :5 אם f n = log n c, g n = n d אזי הערה: בקורס זה אנו תמיד מתכוונים ללוגריתם בבסיס )השקול עד כדי קבוע ללוגריתם בכל בסיס אחר(. הוכחת טענות 4-5: נראה שלא קיים n 0 N כך ש- n. c > d log n נתבונן בגבול )ונשתמש בכלל לופיטל(: li n d ln n n c d d ln n = li n n c = li n n c n c = 0 מהגדרת הגבול קיבלנו שלא קיים n 0 כנ"ל. כעת כדי להוכיח את טענה 4 נשים לב ש- n d = c log c n d = c d log c log n ועכשיו מ- ( ) מקבלים )עבור log (c) d ו- ( n n d < c כמו שרצינו. באופן דומה עבור טענה 5 מקבלים: log n c < n d log n < n d c ויש לנו בדיוק את מה שרצינו. ניתוח סיבוכיות של אלגוריתמים רקורסיביים ראשית, נכתוב את מיון הבועות בתור אלגוריתם רקורסיבי )כאשר בכל פעם ממיינים מערך בגודל קטן יותר(: BUBBLE SORT(A n ) if n > BUBBLE A n BUBBLE SORT(A n ) BUBBLE A n for j to n if A j > A j + ten swap(a j, A j + ) ניתן לראות בקלות ש- BUBBLE פועל ב-,Θ(n) כי הלולאה מתבצעת Θ n פעמים, ובתוך הלולאה אנו עושים לכל היותר מספר קבוע של פעולות )השוואה, החלפה וכד'(. ניתן לכתוב את משוואת הרקורסיה של האלגוריתם על ידי הבנת הקשר בין זמן הריצה של האלגוריתם עבור קלט בגודל n ועבור קלטים קטנים יותר )ברקורסיה(. במקרה שלנו: T n = T n + Θ n

4 T = Θ() כיצד פותרים משוואות רקורסיביות מהסוג הזה? אחת הדרכים היא השיטה האיטרטיבית, שכרוכה בהצבה אחר הצבה עד ש"ברור" מה הביטוי שמתקבל. במקרה שלנו, מהגדרת Θ(n) מתקבל: טענה 6 א': סיבוכיות זמן הריצה של BUBBLE SORT הרקורסיבי היא Θ n T n T n + cn T n + c n + cn T n 3 + c n + c n + cn T + c + 3c + + n c + cn = T + n i= i = T + c n n + הוכחה: בביטוי שקיבלנו מופיע וכמובן כל הקבועים הכפליים והביטויים הזניחים יחסית ל- n מושמטים, ולכן קיבלנו ) T n = O(n ובאופן סימטרי לחלוטין נוכל להראות את הכיוון ההפוך ) T n = Ω(n ולהסיק ש-, T, n = Θ n כלומר שהגרסה הרקורסיבית של מיון הבועות מתנהגת באותו אופן )אסימפטוטית( כמו הגרסה n האיטרטיבית. הערה: אמנם בהגדרת,O,Θ Ω מופיע גם n 0 וגם c, אך קל לראות שאם בוחרים c כאוות נפשנו, ניתן להגיע למצב שבו = 0 n ואז לא צריך להתחשב בו בכלל. דרך אחרת לפתור משוואת רקורסיה מסוג זה היא שיטת הניחוש וההוכחה באינדוקציה. כאן פשוט ננחש ש- T n = O n וננסה להוכיח זאת באינדוקציה. טענה 6 ב': T n cn עבור c כלשהו. הוכחה: בסיס האינדוקציה: n =, T c מתקיים כי אנו יכולים לבחור את c כרצוננו וידוע T = O. c : T c הנחת האינדוקציה: עבור,n מתקיים.T n cn צעד האינדוקציה: רוצים להראות ש- + n.t n + c נציב: T n + T n + c n + cn + c n + = c n + n + c n + במעבר הראשון השתמשנו בהגדרת Θ במשוואת הרקורסיה, במעבר השני השתמשנו בהנחת האינדוקציה על T n והמעבר השלישי ברור. לכן קיבלנו T n = O n ובאופן דומה מוכיחים את הצד השני של הטענה. מיון מיזוג Sort Merge נתבונן באלגוריתם מיון אחר מיון מיזוג ונפעיל עליו את עקרונות הניתוח הרקורסיבי שראינו קודם, וכן עקרונות מתקדמים יותר. זהו אלגוריתם ממשפחת "הפרד ומשול" Conquer(,)Divide and ובו מפרקים את הבעיה לחלקים קטנים, פותרים את הבעיות הקטנות ולבסוף מאחדים את התוצאות החלקיות יחד. במקרה שלנו, מחלקים את המערך לחצאים עד שמגיעים למערך בגודל שהוא מקרה הבסיס, ואז מאחדים את התוצאות החלקיות למערך ממוין.

5 MERGE SORT A n if n > MERGE SORT A n MERGE SORT A n + n MERGE A n, A n + n, A n MERGE A, B, C n l, i, j do wile i < n or j < n C l in A i, B j ifiniu was A i, increent i, else increent j increent l המיון עצמו מתבצע כאן במהלך המיזוג המיזוג מבטיח שבמערך C, שהוא הפלט של האלגוריתם, האיברים נמצאים בסדר ממוין. ניתן להתבונן בעץ הרקורסיה על מנת להבין מה קורה במהלך המיון בכל קודקוד בעץ )עד שמגיעים לעלים( יש התפצלות לשני תת-מערכים, ובכל קודקוד מתבצע MERGE של שני הקודקודים שמתחתיו. כמו כן, ברור ש- MERGE היא בעלת סיבוכיות של Θ n מאחר שהאלגוריתם "נוגע" פעם אחת בכל איבר במערך הפלט. לכן נוכל לכתוב את משוואת הרקורסיה של :MERGE SORT T n = T n T = Θ() + Θ n כעת נרצה לבדוק מה זמן הריצה האמיתי של האלגוריתם. טענה :7 סיבוכיות זמן הריצה של MERGE SORT היא.Θ n log n cn k הוכחה: נתבונן בעץ הרקורסיה, בכל שורה בעץ יש k פעולות MERGE )כאשר k חזקה של (, ובכל פעולת MERGE מתבצעות פעולות בסיסיות. לכן בכל שורה יש לנו cn פעולות, וכן יש לנו log n שורות כיוון שבכל פעם שיורדים בעץ, מחלקים את מספר האיברים במערך ב-, ועוצרים כשהגענו לעלים שבהם מספר האיברים הוא )הנחנו כאן ש- n חזקה של.) לכן קיבלנו T n = O n log n ומשיקולים דומים גם = n T.T n = Θ n log n ולכן Ω n log n מה שראינו כאן הוא מקרה פרטי של משפט המאסטר הכללה של משוואות הרקורסיה לכל אלגוריתם מסוג "הפרד ומשול". כעת נייצר את המשפט עבור כל המקרים השונים, ומשוואות הרקורסיה שאנחנו מתבוננים בהן הן מהצורה: T n = at n b + Θ nk במלים אחרות, בכל שלב מחלקים את הבעיה ל- a בעיות שכל אחת בגודל. במקרה האחרון שהסתכלנו עליו n b היה לנו = k a = b =, )עבור.)MERGE SORT

6 אם נתבונן בעץ הרקורסיה, אזי ברור שבכל שלב העץ מתפצל ל- a חלקים שבכל אחד מהם הבעיה נהיית קטנה יותר פי b. סכום העבודה בשורה הראשונה הוא פשוט cn k עבור קבוע כלשהו, בשורה השנייה סכום העבודה הוא k a c n k וכן הלאה. אם נסכום את כל העבודה נקבל:, בשורה השלישית סכום העבודה הוא b ac n b cn k + cn k a b k + a cnk b k + + cn k a l b k + כמובן שביטוי זה מסתיים לאחר שמגיעים לעלים, כלומר מעניין אותנו כמה שורות יש בעץ. נסמן (n) = log b ואז מספר השורות הוא כמובן +. בשורה האחרונה של העץ יש לנו a עלים, והעבודה המתבצעת בשורה התחתונה היא לפיכך Θ. a = Θ a log b n כעת ננסה לחשב את הסכום, שהוא סכום סדרה הנדסית: T n cn k l=0 a b k l עכשיו נסמן q = a ונבחין בין שלושה מקרים: b k אם < q הסדרה היא סדרה יורדת, והשורה הראשונה תתרום הכי הרבה עבודה: T n cn k q+ q+ k = cn cn k = O nk q q q q + q יש לשים לב כאן שבכיוון השני )Ω( צריך עדינות כדי להראות ש- גדול מקבוע. אם כך במקרה זה מקבלים - T n = Θ n k כלומר העבודה שנעשית בשורה הראשונה של העץ היא הדומיננטית. אם = q אזי יש לנו סכום של, כלומר: T n cn k + = cn k log b n = Θ n k log n כלומר במקרה זה קיבלנו T, n = Θ n k log n וזה אכן מתאים למה שגילינו על.MERGE SORT אם > q, אזי אנחנו מצפים שהגורם הדומיננטי יהיה בשורה האחרונה, כי הסדרה עולה: T n cn k q+ q = Θ n k q = Θ n k a b k = Θ n k a b k = Θ a כך למעשה "חישבנו" את:.T n = Θ n log b a כלומר במקרה זה קיבלנו = Θ a log b n = Θ n log b a T n = at n b אזי: משפט : )משפט המאסטר( אם + Θ n k T n = Θ nlog b a T n = Θ nk T n = Θ nk log n אזי a > b k אזי a < b k אזי a = b k אם אם אם הוכחה: החישוב לעיל מהווה הוכחה.

7 מיון הכנסה Sort Insertion במיון זה, בכל שלב k יהיו לנו k איברים ממוינים בהתחלה של המערך, ו- n k איברים לא ממוינים עדיין בסופו. בכל שלב, ניקח את האיבר ה- + k ונכניס אותו למקום הנכון שלו בין + k האיברים הראשונים. באופן דומה אפשר גם לממש את האלגוריתם בצורה רקורסיבית : INSERTION SORT A n for i to n val A i j i wile j 0 and A j > value A j + A j decreent j A j + value INSERTION SORT A, curr, n if curr = n + ten return INSERT A curr, A curr INSERTION SORT(A, curr +, n) זמן הריצה של האלגוריתם במקרה שהמערך ממוין )המקרה הטוב ביותר( הוא,O(n) כיוון שצריך רק להשוות את האיבר החדש עם הקצה של הטווח הממוין. במקרה הגרוע, למשל כאשר המערך ממוין בסדר הפוך, בכל איטרציה יש לסרוק את כל החלק הממוין של המערך, אז אם נסכום ונזרוק חצי מהאיברים נקבל O n )באופן דומה להוכחות אחרות(. מסתבר שגם המקרה הממוצע של INSERTION SORT הוא O n ולכן הוא שימושי רק עבור מערכים מאוד קטנים )נחשב מאוד יעיל עבורם( או עבור קלט ממוין בהסתברות גבוהה. מיון בזמן ליניארי רוב האלגוריתמים למיון משתמשים בהשוואות על מנת למיין את האיברים. במקרה זה )נראה בהמשך(, קיים חסם תחתון על סיבוכיות זמן הריצה של האלגוריתם והוא Ω n log n )טענה 3(. עם זאת, במקרים מיוחדים אנו יכולים לבצע מיון גם בזמן ליניארי. למשל, האלגוריתם COUNTING SORT מניח שהקלט הוא n מספרים שכולם בטווח, k,. COUNTING SORT A n, B n, k initialize C k an array for i to n increent C A i for j to k C j C j + C j for j n downto B C A j A j decreent C A j הרעיון הוא לספור את מספר האיברים הקטנים או שווים לכל{ k j.,}, עבור כל j, המספר הזה הוא האינדקס הגבוה ביותר של j במערך. אנו יכולים להשתמש במידע הזה כדי לשחזר את המערך הממוין כולו.

8 סיבוכיות זמן הריצה של האלגוריתם היא כמובן (k.θ(n + מדוע האלגוריתם עובד? לאחר הלולאה הראשונה, ספרנו את מספר הפעמים שכל j מופיע במערך. לאחר הלולאה השנייה, ספרנו את מספר האיברים במערך הקטנים או שווים ל- j. לאחר מכן, רצים על המערך מהסוף להתחלה ובכל פעם האינדקס הגבוה ביותר של j שלא תפוס עדיין במערך נמצא ב-,C[j] שאותו מעדכנים לאחר כל הכנסה. כתוצאה מזה, כל איבר נכנס למקום שלו באופן מדויק. הגדרה: אלגוריתם מיון נקרא יציב אם עבור כל A[j] i < j A i = במערך המקורי, המקומות j i, בהתאמה במערך הממויין מקיימים j.i < הערה: המיון COUNTING SORT הוא מיון יציב. קל לראות זאת כיוון שהאיברים מהמערך המקורי מוכנסים למערך החדש מהסוף להתחלה, בדיוק לפי הסדר שבו הם היו במערך המקורי. מיון מהיר Sort Quick במיון זה בוחרים pivot מקום כלשהו במערך ומחלקים את המערך לחלק הקטן ממנו והחלק הגדול ממנו )תהליך זה נקרא.)partition לאחר החלוקה מחזירים את המקום של ה- pivot במערך החדש, וממשיכים למיין ברקורסיה את שני החלקים )משמאל ל- pivot ומימין לו(. יש לנו הרבה אפשרויות לבחור את ה- pivot האיבר הימני ביותר במערך: QUICK SORT A left, right if rigt > left PARTITION A left, rigt QUICK SORT A left, QUICK SORT A +, rigt בתוך,PARTITION אז במקרה כאן נבחר את ה- pivot להיות PARTITION A left, right L left, R rigt, Pivot A rigt for j left to rigt if A j < Pivot ten B L A j, increent L else B R A j, decreent R B L A rigt copy B to A return L כאן קיבלנו אלגוריתם אמנם פשוט אבל בזבזני כי אנחנו יוצרים מערך חדש לצורך התוצאות. אין בכך צורך ניתן לממש.partition in-place כלומר, יהיו לנו שני מצביעים הרצים על המערך )משמאל לימין ומימין לשמאל( והם מתקדמים עד שהם פוגשים משהו "לא מתאים". במקום שבו המצביעים מתנגשים, מכניסים את ה-.pivot PARTITION A left, right L left, R rigt, Pivot A rigt wile TRUE wile A L Pivot increent L wile A R Pivot decreent R

9 if L > R ten return R swap A L, A R הערה: זו רק אפשרות אחת לכתוב את,PARTITION ניתן גם לבצע זאת באמצעות מצביע אחד בלבד )מפתרון תרגיל 3(: PARTITION3 A left, right, pivotindex Pivot A pivotindex swap A pivotindex, A rigt storedindex left for i left to rigt if A i Pivot ten swap A i, A storedindex and increent storedindex swap A storedindex, A rigt return storedindex כעת נרצה לנתח את סיבוכיות זמן הריצה של האלגוריתם. קל לראות שכל הגרסאות של PARTITION פועלות ב- Θ, n אפילו הגרסה הבזבזנית ביותר שבה מקצים מערך נוסף. אבל איך נתבונן באלגוריתם כולו? אנו יודעים לכתוב את משוואת הרקורסיה הבאה, כתלות ב- שהוא מיקום ה- pivot לאחר ש- PARTITION חוזר: T n = T + T n + Θ(n) אנחנו לא יודעים איך לנתח את זה כי זה מתנהג באופן שונה עבור כל, וכמובן שהבחירה של ה- משתנה בכל שלב ברקורסיה. אבל, אנחנו יכולים לבחון מקרי קצה. 0 n אם המערך ממוין ואנחנו בוחרים את ה- pivot להיות המקום הימני ביותר, אזי = n בכל פעם ולכן מקבלים: T n = T n + Θ n = Θ n )אפשר גם להוכיח ישירות באמצעות עץ רקורסיה למשל(. אם = n תמיד )הבחירה ה"מושלמת" של ה- )pivot אזי אנו מקבלים את עץ הרקורסיה של,MERGE SORT שהוא בעומק log n ובכל שלב יש n פעולות, ולכן T n = Θ n log n )ניתן גם היה לטעון ישירות ממשפט המאסטר(. בכל 9 ו- = 9 )בחירה לא טובה כל כך של ה-,)pivot אזי בעץ שלנו יש התפצלויות ל- אם 0 n 0 n שלב, אבל עומק הענף המקסימלי הוא עדיין רק, log 9 וזה בסה"כ הבדל של קבוע מ-.log n כיוון 0 n שהעבודה המקסימלית בכל ענף היא עדיין n )ויש ענפים שנגמרים באמצע(, אנחנו עדיין מקבלים.Θ n log n למעשה, נראה כאילו עבור "כמעט" כל הקלטים )למעט ( = n יוצאות לנו תוצאות לא רעות בכלל. אבל איך נדע מה קורה במקרה ה"ממוצע", או "בדרך כלל"? נכניס הסתברות לכל הסיפור. טענה 8 א': עבור כל קלט, T n = O n הוכחה: נתבונן על הקלט הגרוע ביותר, ובו: T n = ax q n T q + T n q + Θ(n) ונשתמש בהגדרת Θ ונקבל:

10 T n ax q n T q + T n q + dn כעת נוכיח באינדוקציה ש-.T n = O n בסיס האינדוקציה: T < c מתקיים. נניח כי k < n, T k ck וכעת נרצה להראות ש-.T n cn T n ax q n cq + c n q + dn = cax q n q + n q + dn הביטוי q q + n מקבל מקסימום על הטווח n q באחד הקצוות, כיוון שזוהי פרבולה "מחייכת". לכן יש לנו: ax q n cq + c n q = + n = n n + 5 < n n n 9 מכאן אנחנו מקבלים ישירות: T n c n n + dn cn c > d טענה 8 ב': )ללא הוכחה( עבור כל קלט, T. n = Ω n log n מהטענה נובע שמקרי הקצה שהסתכלנו עליהם קודם אכן היו מייצגים, עבור הקלט הטוב ביותר והקלט הגרוע ביותר של האלגוריתם. הגדרה: לקלט שעבורו סיבוכיות זמן הריצה היא המקסימלית קוראים הקלט הגרוע ביותר case(.)worst הגדרה: לקלט שעבורו סיבוכיות זמן הריצה היא המינימלית קוראים הקלט הטוב ביותר case(.)best הגדרה: לקלט שעבורו סיבוכיות זמן הריצה היא הממוצעת על פני כל הקלטים קוראיםהקלט הממוצע ( average.)case הערה: ייתכן ששלושת המקרים הם אותו הקלט, או שיש יותר מקלט אחד עבור כל מקרה. בסה"כ עבור בעיית המיון יש לנו!n קלטים אפשריים )לא נאפשר כפילויות(. לכן, מעניינת אותנו הסיבוכיות הממוצעת עבור כל הפרמוטציות )תמורות( האפשרויות של הקלטים: T(n) = σ T n for input σ n! טענה :9 )ללא הוכחה( T n = Θ n log n מהטענה ברור שמקרה הקצה הגרוע ביותר ( Θ( n הוא במקרה זניח יחסית לאחרים, ובדרך כלל הקלט יתנהג כמו עבור הקלט הטוב ביותר ( n Θ( n log עד כדי קבוע. בכל זאת, כדי לומר שהאלגוריתם עובד עבורנו ב- Θ n log n הנחנו כאן הנחה גדולה שהקלטים נבחרים באקראי. אולי מישהו משתמש ב- QUICK SORT כדי למיין רק מערכים ממויינים? אנו רוצים לשנות את האלגוריתם כך שיהיה תמיד ) n Θ(n log ללא תלות בקלט. אפשרות אחת היא לעשות רנדומיזציה של הקלט בהתחלה, אך אפשרות טובה יותר היא פשוט לבחור את ה- pivot באקראי במקום לבחור את האיבר הימני ביותר במערך. כלומר, במקום להניח שהקלטים מתפלגים אקראית נניח שה- pivot נבחר באקראי ואז נוכל לנתח את הסיבוכיות של האלגוריתם באופן מדויק.

11 מונחים בסיסיים בהסתברות הגדרה: אוסף המאורעות שיכולים להתרחש נקראים מרחב המדגםΩ. למשל, הטלות מטבע יוצרות את מרחב המדגם Ω, = eads, tails והטלות קובייה יוצרות את מרחב המדגם.Ω 3 = {HH, HT, TH, TT} שתי הטלות מטבע יוצרות את מרחב המדגם.Ω = {,,3,4,5,6}. A Ω, P A 0. P Ω = 3. A, B Ω A B =, P A B = P A + P B הגדרה: על מרחב המדגם נגדיר פונקציית הסתברות :P Ω R המקיימת: פונקציית ההסתברות מייצגת עד כמה סביר מאורע מסוים. למשל, במקרה של קובייה הוגנת פונקציית 6 ההסתברות מחזירה לכל אפשרות הטלה. ייתכן כמובן גם מצב לא הוגן, למשל מטבע לא הוגן:.P H = p, P T = p הגדרה: משתנה מקרי היא פונקציה שהערך שלה הוא הסתברותי והיא מוגדרת על מרחב המדגם, אולם רק עבור המאורעות האלמנטריים במרחב המדגם. למשל, סכום ההטלות של שתי קוביות זהו משתנה מקרי על מרחב המדגם של הטלות שתי קוביות)הקבוצה.) 6 { 6} הגדרה: תוחלת של משתנה מקרי היא ממוצע משוקלל של הערכים השונים וההסתברויות שלהם, כלומר עבור משתנה מקרי X, נסמן את התוחלת שלו ב: E X = x Ω P X = x x נחשב למשל את התוחלת של המשתנה המקרי X המוגדר להיות ערך ההטלה של קוביה. יש לנו: E X = 6 x= x = P x a E X a טענה 0: )אי-שוויון מרקוב( יהי X משתנה מקרי אי-שלילי ו- > 0 a, אזי: E X = x=0 a P X = x x = P X = x x + P X = x x x=0 = a P X = x x=a x=a = ap x a P x a x=a E X a P X = x x x=a P X = x a הוכחה: הערה: במקרים רבים, אי-שוויון מרקוב מספק חסם מאוד לא הדוק על ההסתברות, ולכן יש להשתמש בו בזהירות כדי לא לאבד אינפורמציה.

12 הגדרה: חיתוך המאורעות,A B הוא המאורע שבו שניהם מתרחשים, ומסמנים: (B.P(A 6 למשל, המאורע שבו הטלת קוביה היא זוגית וגם לכל היותר 3 הוא בעל הסתברות )ומכיל את המאורע האלמנטרי (. הגדרה: איחוד המאורעות,A B הוא המאורע שבו אחד מהם או שניהם מתרחשים, ומתקיים: P A B = P A + P B P(A B) הגדרה: הסתברות מותנית היא ההסתברות של מאורע מסוים בהינתן שמאורע אחר התרחש, ומתקיים: 3 P B A = P A B P A למשל, ההסתברות שהטלת הקובייה הייתה 3 בהינתן שהטלת הקובייה הייתה אי-זוגית היא לפי האינטואיציה,. P 3 odd = P 3 odd P odd = P 3 וגם לפי הנוסחה: = P odd 3 הגדרה: מאורעות בלתי תלויים A, B מקיימים P(B).P B A = P A B P B = P B A = P A P A B = P A P B במקרה זה ניתן לקבל: לדוגמה, שתי הטלות מטבע הן מאורעות בלתי תלויים. הגדרה: המשלים של מאורע מסוים הוא אוסף כל המאורעות שבהם המאורע לא התרחש, ומתקיים:.P A + P not A = טענה : יהיו X, Y משתנים מקריים, אזי E X + Y = E X + E Y הוכחה: E X + Y = i i + j P X = i Y = j = i P X = i Y = j + j P X = i Y = j j i j = i P X = i Y = j + j P X = i Y = j i j i j = i P X = i Y = j + j P X = i Y = j i j j i = i P X = i + P Y = j = E X + E Y i j

13 אנו רוצים להגדיר משתנה מקרי שהוא זמן הריצה של האלגוריתם, Quick Sort רנדומי בחזרה לבחירת ה- pivot בצורה אקראית: ולחשב את תוחלת זמן הריצה. הערה: אפשר לחשב את הממוצע של זמני הריצה לכל הקלטים בהנחה שבוחרים קלט באחראי, או שאפשר לקבע קלט ולבחור את ה- pivot באקראי ולהתבונן בתוחלת זמני הריצה. שני הדברים אינם שקולים! טענה : תוחלת זמן הריצה של RANDOMIZED QUICK SORT על קלט קבוע היא Θ. n log n הוכחה: נרצה לכתוב את נוסחת הרקורסיה עבור E, T n תוחלת זמן הריצה: E T n E T + E T n + Θ n זה לא נכון, כיוון שאנחנו לא יודעים מהו - הוא נקבע באקראי. לכן אנחנו צריכים להיזהר יותר ולהסתכל על : n הממוצע של כל האפשרויות לבחור את, שההסתברות לכל אחת מהן היא אחידה ושווה ל- E T n = n = n E T + E T n + Θ(n) ונשים לב שכאן E T למשל הוא לא ממוצע על אותו ערך שחוזר על עצמו כמה פעמים, כיוון שבכל קריאה רקורסיבית תהיה לנו עבודה נוספת שתלווה בהגרלה חדשה שלpivot. נפשט את הביטוי: E T n = n = E T + E T n n + Θ n n 0 n = E T + (E(T n ) + Θ n = =0 =n =0 E T n + Θ(n) ועכשיו מהגדרת Θ מקבלים: n =0 E T n + c n E T n n =0 E T 0 = Θ c E T 0 c E T n + c n מה שקיבלנו הוא אמנם פשוט בהרבה, אבל זו עדיין משוואת רקורסיה עם היסטוריה מלאה התוחלת של T n תלויה בכל ה- ( T( -ים הקטנים יותר, ולא רק באחד או שניים מהם. למען הפשטות, נגדיר פונקציה חדשה (n) U c שתקיים את אי השיוויון, כלומר: U c n = U c 0 = c n =0 n U c + cn טענה א': U c n E T n U c n

14 nu c n = n =0 הוכחה: באינדוקציה פשוטה, ר' למשל פתרון תרגיל 4 כעת נציב בביטוי שיש לנו n ו- + n ונקבל את שני הביטויים: U c + cn n + U c n + = U c + c n + n =0 n + U c n + nu c n = U c n + c n + cn n + U c n + = n + U c n + cn + c U c n + = n + n + U cn + c c n + n + כעת נחסר את המשוואה הראשונה מהשנייה: עכשיו קיבלנו משוואת רקורסיה עם היסטוריה של שלב אחד אחורה בלבד ולא היסטוריה מלאה. כדי לפתור c cn +c n+ אותה, נשים לב לעובדה הפשוטה ש- c מחסם מלמעלה )O(: וקיבלנו שני אי שוויונות בשני הכיוונים הרצויים. נתחיל U c n + n + n + U c n + c n + n + n + = n + n + n + n + n + n + n n + n n + c + n + n + n U c n + c + c n + c + n + n + c U c n + n + n n U c n + c + n + n + n + n + c + + c + U c (0) c + n + n + c עכשיו ניזכר ש- U c 0 c ולכן גם אותו אפשר להחליף ב- c ולקבל לבסוף: U c n + n + c n+ + j j = = n H ועל מנת שנוכל לסיים אנחנו צריכים לחשב אותו. n j = j אז בעצם קיבלנו את הטור ההרמוני: טענה ב': H n = Θ log n הוכחה: ראשית נניח n. = k אזי נוכל לחלק את הטור לבלוקים כאשר הגודל של בלוק k הוא k את סכומם s. k אזי: איברים, ונסמן s k = k + k k+ s k k k+

15 s k k k = n H אז מקבלים: k מאחר שכל הטור הוא פשוט j 0= s j. k H n k log n + = H n k log n + k < n + k k < log n + k נבחר k כך ש- k. k < n כעת נפתח: כעת ממונוטוניות H n ברור ש- ) k H k < H n H( ולכן H n k שקיבלנו ע על k יש לנו: מהצבה בחסם כרג log n + < H n log n + + log n + < H n log n + וכעת יש לנו בשני האגפים ביטויים שהם Θ log n ומייד ניתן להסיק H. n = Θ log n הוכחנו את טענה ב'. קודם היה לנו ביטוי על ) + (n U c ונחזור אליו ע"י הצבת + n :H n + = Θ log U c n + n + c H n + + = n + cθ log n + + n + c = O n log n באופן סימטרי לחלוטין אפשר לקבל גם U c n + = Ω n log n ולכן לבסוף ) n.u c n = Θ(n log ניזכר שבמקור חסמנו את E T n של RANDOMIZED QUICK SORT משני הצדדים באמצעות U c n ו- (n),u c ולכן בעצם יש לנו: Θ n log n E T n Θ n log n E T n = Θ n log n אם מעניין אותנו לדעת כמה סביר הוא המקרה שבו זמן הריצה יהיה משמעותית יותר גדול מהתוחלת, אפשר למשל להשתמש באי-שוויון מרקוב )טענה 0(. לדוגמה, נוכל לומר שב- 99% מהמקרים זמן הריצה חסום ע"י.00cn log n חסם תחתון על אלגוריתמי מיון במודל ההשוואות כמעט בכל האלגוריתמים עד עכשיו )למעט )COUNTING SORT השתמשנו במיון במודל ההשוואות מיון שלא מתעניין בתוכן של הקלט אלא רק ביחסים בין איברי הקלט, תוך ביצוע השוואה בין האיברים השונים. נרצה לטעון טענה לגבי כל אלגוריתם מיון באשר הוא כל עוד הוא משתמש במודל ההשוואות כדי לחסום את זמן הריצה

16 שלו. זה יעודד אותנו במקצת כי המשמעות היא שאין אלגוריתם מיון אסימפטוטית טוב יותר מ- RANDOMIZED QUICK SORT למשל. טענה 3: אלגוריתם מיון דטרמיניסטי במודל ההשוואות יבצע ) n Ω(n log צעדים במקרה הגרוע ביותר. הערה: אנו מוכיחים את הטענה לגבי אלגוריתם מיון דטרמיניסטי, אולם ניתן להרחיב אותו בלא קושי מיוחד גם לאלגוריתם המשתמש באקראיות. הוכחה: נייחס לכל אלגוריתם מיון במודל ההשוואות מבנה הנקרא עץ הכרעה. האלגוריתם בשלב כלשהו שואל שאלה )השוואה(, למשל האם x, < x והתשובה היא כן או לא. בכל תשובה נוצר נתיב ריצה מסוים שנבחר, ולכן בעצם נוצר עץ )בינארי( שבכל קודקוד שלו יש שאלה ותוצאת המיון הסופית היא עלה כלשהו בעץ. לפיכך, סיבוכיות האלגוריתם היא פשוט עומק העץ המסלול הארוך ביותר ונסמנו D. כדי שאלגוריתם המיון יהיה נכון, הוא חייב להיות נכון לכל קלט אפשרי. במקרה שלנו )נתעלם מכפילויות( יש לנו!n קלטים אפשריים בגודל n, ולכן גם!n עלים בעץ ההכרעה. לצורך ההוכחה נסתפק בכך שבעץ לפחות!n עלים. טענה 3 א': לעץ הכרעה של אלגוריתם מיון במודל ההשוואות חייבים להיות בדיוק! n עלים. הוכחה: קיימות!n פרמוטציות )תמורות( של קלט בגודל n )נזכור שאנו מניחים שכל איברי הקלט שונים זה מזה(. האלגוריתם דטרמיניסטי ומשייך לכל קלט מסלול בעץ. בנוסף, כיוון שכל התמורות שונות זו מזו, גם העלים בעץ שונים זה מזה כלומר אין שני קלטים המובילים לאותו העלה. לפיכך, ההתאמה בין קלט מסוים לעלה בעץ )כלומר המסלול( היא העתקה חח"ע ועל, לעץ בינארי בגובה D יש לכל היותר D נרצה לחלץ מכאן את D באמצעות הוצאת log ונקבל: טענה 3 ב': ) n log n! = Θ(n log ולכן יש בדיוק!n עלים בעץ ההכרעה. עלים, אם הוא עץ מלא. לפיכך, נוכל לחסום את מספר העלים: D #leaves n! running tie D log n! הוכחה: ראשית, log () log n! = log n + log n log + וכאן כמובן כל אחד מהאיברים קטן או שווה ל- log n ולכן זה ) n O(n log אבל אנחנו גם יודעים שיש לנו חצי מהאיברים שגדולים מ- כלומר log n! n log n = n log n n log ז"א ) n log n! = Ω(n log ולכן גם = n! log ) n Θ(n log כפי שרצינו.,log n מהטענה האחרונה נובע ש- ) n D = Ω(n log ולכן קיבלנו את החסם התחתון על כל אלגוריתם מיון במודל ההשוואות כפי שרצינו. הוכחה אלטרנטיבית של טענה 3: נשתמש בטענת עזר שתהפוך את החיים לקלים מאוד. d l עומק העלה )מרחקו l leafs T טענה 3 ג': בכל עץ בעל עלים מתקיים d l log מהשורש(. כאשר

17 הוכחה: אינדוקציה על מספר העלים. עבור = הטענה מתקיימת. נניח עבור כל n ונוכיח עבור +. ניקח עץ עם + עלים, ונניח שלשורש העץ יש שני בנים, תתי עצים T,, T עם, עלים בהתאמה. אזי לפי הנחת האינדוקציה: l leafs T l leafs T d T l d T l log log כמו כן כמובן ברור שעומק של עלה בכל אחד מתתי העצים קטן ב- מעומק העלה בעץ המקורי. לכן מתקיים: l leafs T d T l = l leafs T d T l + + l leafs T d T l + = d T l + + d T l + l leafs T l leafs T = + l leafs T d T l + d T l l leafs T וכעת מהנחת האינדוקציה ניתן לקבל: = + log + log log וכאן אי-השוויון האחרון מתקיים כיוון ש- + = ולכן אם נתבונן בפונקציה: x = + x log x + x log x log. לכן סיימנו את האינדוקציה. x = וכאן = 0 כאן המקסימום הוא ב- נחזור להוכחה האלטרנטיבית של טענה 3. כיוון שבעץ הכרעה של אלגוריתם מיון על קלט בגודל n יש בדיוק!n עלים )טענה 3 א'(, סיבוכיות זמן הריצה במקרה הממוצע היא בדיוק העומק הממוצע של העלים, ולפי טענה 3 ג' זה לפחות n!,log כלומר.Ω n log n פרק עצים בינאריים ועצי חיפוש בינאריים עץ בינארי הגדרה: עץ הוא גרף קשיר ללא מעגלים. הגדרה: עץ בינארי הוא עץ בעל שורש יחיד שבו לכל קודקוד בין 0 ל- ילדים )בנים(. הגדרה: שורש העץ הוא הקודקוד שאין לו הורה.

18 הגדרה: עלה הוא קודקוד ללא ילדים. הגדרה: קודקוד פנימי הוא קודקוד שיש לו ילד אחד או שני ילדים. הגדרה: גובה העץ או עומק העץ אורך המסלול הארוך ביותר מהשורש לעלה בעץ לרוב יסומן ב- D. הגדרה: עומק של קודקוד x הוא אורך המסלול מהשורש ל- x ומסומן d. i הגדרה: גובה של קודקוד x הוא אורך המסלול הארוך ביותר מ- x לעלה כלשהו בעץ ומסומן. i הגדרה: עץ מלא הוא עץ שבו לכל קודקוד 0 או בנים )אין קודקוד עם בן אחד(. הגדרה: עץ שלם הוא עץ בינארי שכל הרמות שלו מלאות וכל העלים שלו נמצאים באותו הגובה. בעץ בינארי שלם יש D עלים, ו- D + D = קודקודים פנימיים. הגדרה: עץ בינארי כמעט שלם הוא עץ בינארי שלם, למעט הרמה התחתונה שבה חלק מהעלים נמחק. כל העלים משמאל עד לנקודה מסוימת קיימים )כמו בעץ שלם(, ומאותה נקודה ימינה אין עלים ברמה התחתונה. בעץ בינארי כמעט שלם מתקיים #leaves D )כאשר שוויון מתקיים אם העץ שלם(. טענה 4: בעץ בינארי כמעט שלם מתקיים D log n כאשר D עומק העץ, n מס' הקודקודים בעץ. הוכחה: בעץ בינארי כמעט שלם בגובה יש לכל היותר + איברים בסה"כ )אם הוא שלם זה נובע מהאבחנות לגבי מס' העלים ומס' הקודקודים הפנימיים בעץ בינארי שלם(, ולכל הפחות + = איברים )אם ברמה התחתונה יש עלה אחד בלבד(. לפיכך: n + < + D log n < D + תור קדימויות, ערימה כעת נוכל להתחיל לדבר על מבני נתונים אמיתיים. כדי לעשות זאת, אנו משתמשים במושג של ADT = Abstract,Data Type המספק הפרדה בין הפעולות שאנו רוצים לעשות על מבני הנתונים לבין האופן שבו מבנה הנתונים ממומש )למעשה, זהו ההבדל בין interface ל-.)ipleentation ראינו כבר מספר דוגמאות ל-,ADT למשל תור )queue( ומחסנית,)stack( שאת שניהם אפשר לממש באמצעות רשימה מקושרת או באמצעות מערך. תור קדימויות Queue( )Priority מספק את הפעולות הבאות עבור איברים בעלי קדימות )מספרית( כלשהי: MAX(S) מחזיר את האיבר עם הקדימות הגבוהה ביותר MAX(S) - EXTRACT מוציא את האיבר עם הקדימות הגבוהה ביותר מהתור ומחזיר אותו x מכניס לתור את הרשומה - INSERT(S, (x key להיות x משנה את הקדימות של הרשומה - INCREASE KEY(S, x, key) את תור הקדימויות ניתן לממש באמצעות מבנה נתונים שנקרא ערימה.)Heap( הגדרה: תכונת הערימה אם A הוא תור הקדימויות, אזי A[x] A. parent x

19 הגדרה: ערימה היא עץ בינארי כמעט שלם, ולכל קודקוד הקדימות שלו והערכים בקודקודי העץ מקיימים את תכונת הערימה. הערה: כל ההגדרות לעיל מגדירות ערימת מקסימום Heap(,)Max אך ניתן לדבר גם על ערימת מינימום עם ההגדרות המתאימות עבורה Heap(.)Min הערה: אין שום הבטחה לסדר בתוך הערימה למעט תכונת הערימה. למשל, לא מתקיימת תכונת עץ חיפוש בינארי )שנראה בהמשך(. כדי לממש עץ בינארי כמעט שלם, אין צורך במצביעים לילדים ולהורה ניתן לממש אותו באמצעות מערך, כאשר כל רמה k מיוצגת על ידי רצף איברים בגודל k בתוך המערך. אנחנו צריכים כמובן פעולות נביגציה בתוך המערך ימינה, שמאלה ולכיוון ההורה: left x x rigt x x + parent x i מספר האיברים בערימה כמובן משתנה גם, ונעקוב אחריו בכל עת: HEAPSIZE A n כעת נוכל לעבור למימוש של הפעולות השונות על הערימה. נתחיל ב- - MAX זה כמובן קל, כי מובטח לנו בגלל תכונת הערימה שהאיבר הראשון במערך הוא המקסימלי )שורש העץ(: MAX S return A כעת נרצה לממש את.EXTRACT MAX נשים לב לרעיון שגוי אם פשוט נוציא את האיבר הראשון ונזיז את כל שאר האיברים שמאלה, נקבל ערימה לא חוקית! דוגמה: אם הערימה הייתה {00,,99} אזי היא ערימת מקסימום חוקית, אבל לאחר ההזזה שמאלה מתקבלת הערימה {,99} שהיא לא ערימה חוקית. לכן אנחנו צריכים משהו מתוחכם יותר. נחליף את האיבר הראשון באיבר האחרון )כי זה כרוך בהכי פחות הזזות( ואז "נאזן" את הערימה בכל פעם נחליף את השורש עם הבן הגדול ביותר שלו, עד שנגיע לסוף או שהוא יהיה גדול משני הילדים שלו. לצורך ביצוע האיזון הזה, נשתמש בשיטת עזר HEAPIFY :MAX MAX HEAPIFY A, i l left i, r rigt i if l HEAPSIZE A if r > HEAPSIZE A ten r HEAPSIZE a if A l > A i ten largest l else largest i if A r > A largest ten largest r if largest i swap A i, A largest MAX HEAPIFY A, largest

20 הסיבוכיות של MAX HEAPIFY היא O log n כי אנחנו בכל פעם יורדים ברמה אחת, וגובה העץ הוא לכל היותר log n )טענה 4(. כעת אפשר לכתוב את :EXTRACT MAX EXTRACT MAX A ax A A A HEAPSIZE A decreent HEAPSIZE A MAX HEAPIFY A, return ax הסיבוכיות הכוללת של EXTRACT MAX היא גם כן O log n כיוון שאנו מבצעים מספר קבוע של פעולות ואז קוראים ל-.MAX HEAPIFY הערה: הוכחת הנכונות של EXTRACT MAX תלויה בהוכחת הנכונות של.MAX HEAPIFY אם מניחים ש- MAX HEAPIFY נכון )טענה 5( וכן מניחים את טענה 5 ג', אזי ברור שמה שעושים ב- EXTRACT MAX גורם למצב שבו שני הבנים של השורש הם עדיין ערימות מקסימום תקינות, וההפרה היחידה יכולה להיות בשורש. זה בדיוק התנאי של טענה 5 ג', ולכן לאחר ביצוע MAX HEAPIFY עדיין יש לנו ערימה חוקית. כעת נרצה לממש את.INCREASE KEY יש לנו בעיה דומה איבר בערימה שהמפתח שלו משתנה גורם למצב שהוא עשוי להפר את תכונת הערימה )למשל, כי הוא גדול יותר מההורה שלו(. לכן, אנחנו צריכים להעלות אותו למעלה עד המקום הנכון שלו. נשים לב שבדרך אנחנו שומרים על מבנה הערימה, כי אם החלפנו הורה בבן שגדול יותר ממנו, אז הבן הזה כמובן גדול יותר מהבן השני של ההורה, בגלל תכונת הערימה. נכתוב את זה: INCREASE KEY A, i, key if key < A i ten raise error A i key wile i > and A parent i < A i swap A i, A parent i i parent i גם כאן אנחנו מעלים את הקודקוד לכל היותר לכל גובה העץ, כלומר הסיבוכיות היא O. log n נותר לנו לטפל בהכנסה לערימה. כדי לעשות זאת, נכניס את האיבר לסוף המערך )מה שמקל עלינו לבצע את ההכנסה(, אבל ניתן לו קדימות של במקום הקדימות האמיתית שלו. לאחר מכן, נבצע INCREASE KEY כדי להעלות אותו למקום הנכון: INSERT A, key increent HEAPSIZE A A HEAPSIZE A INCREASE KEY A, HEAPSIZE A, key גם כאן הסיבוכיות היא ) n O(log כי למעשה אנחנו עושים מספר קבוע של פעולות ואז קוראים ל-.INCREASE KEY נותר לנו רק לבנות את הערימה מרשימה קיימת של איברים. ניתן לעשות זאת במספר דרכים: O. n log n להשתמש במיון מערך ממוין )בסדר עולה( הוא ערימה חוקית, זמן ריצה:

21 שימוש ב- INSERT עבור כל איבר, n פעמים סה"כ.O n log n לדוגמה, ההכנסה של, n, גורמת לכך שבכל שלב אנו נאלצים לפעפע איבר חדש לשורש של הערימה, כי כל איבר שמוכנס גדול מכל האחרים. לכן, לאיבר ה- j נשלם n c log j ובסה"כ אם ניקח למשל את ה- שההכנסה היא.Ω n log n מעבר על המערך הקיים מהסוף להתחלה ושימוש ב- - MAX HEAPIFY נוכיח שזה O(n) )טענה 6(. איברים האחרונים ברור על פניו גם זה ) n O(n log אך BUILD HEAP A n HEAPSIZE A LENGTH A for i n to MAX HEAPIFY(A, i) טענה 5: אלגוריתם BUILD HEAP יוצר ערימת מקסימום תקינה. הוכחה: ראשית ננסח כמה טענות עזר שנזדקק להן לצורך ההוכחה, ונוכיח אותן. טענה 5 א': כל קודקוד בעץ כמעט שלם הוא שורש של עץ כמעט שלם. הוכחה: כל קודקוד הוא שורש של תת עץ. תת עץ עשוי להכיל חלק מהעלים ברמה התחתונה )או שהוא עצמו ברמה התחתונה, ואז הטענה נכונה באופן ריק(. אם תת עץ זה לא מכיל אף איבר מהרמה התחתונה, אזי הוא נגמר ברמה שלפניו ואז לפי הגדרת עץ כמעט שלם, תת עץ זה הוא עץ שלם )שהוא גם בפרט עץ כמעט שלם(. אם תת העץ מכיל חלק מהרמה התחתונה, אז בהכרח בחלק שהוא מכיל אין חורים )כי אחרת יש חורים בעץ המקורי(. לכן זהו תת עץ כמעט שלם. טענה 5 ב': כל קודקוד בערימת מקסימום הוא שורש של ערימת מקסימום. הוכחה: עבור כל קודקוד בערימה מתקיים ששני הבנים שלו קטנים ממנו )תכונת הערימה(. לפי טענה 5 א', כל קודקוד בעץ כמעט שלם הוא עץ כמעט שלם, ולכן כל קודקוד בערימה הוא שורש של עץ כמעט שלם שמקיים את תכונת הערימה, ולכן הוא שורש של ערימת מקסימום. טענה 5 ג': אם נפעיל את MAX HEAPIFY על קודקוד x ששני בניו הם שורשים של ערימות מקסימום, אזי לאחר סיום ריצת האלגוריתם גם x יהיה שורש של ערימת מקסימום. הוכחה: נוכיח באינדוקציה על גובה העץ. עבור עץ בגובה 0, הטענה נכונה באופן ריק. נניח שהטענה מתקיימת עבור עצים בגובה ונוכיח עבור +. נתבונן בערימה בגובה + ונסמן את השורש שלה ב- r. לאחר הפעלת האלגוריתם, נבחין בין שני מקרים: אם r היה שורש תקין של ערימת מקסימום, אזי הוא המקסימלי מבין בניו ועצמו, ולכן לא עשינו שום דבר והוא עדיין שורש של ערימת מקסימום. אם אחד הבנים של r היה המקסימלי )נסמנו c( אזי החלפנו בינו לבין r וביצענו קריאה רקורסיבית על r במקום החדש שלו. הבן השני של r לא השתנה, ולכן הוא עדיין שורש של ערימת מקסימום; הקריאה הרקורסיבית היא על תת עץ בגובה ולפי הנחת האינדוקציה לאחר סיום ריצת האלגוריתם נקבל ערימת מקסימום תקינה. לכן כעת c הוא שורש של ערימת מקסימום חוקית כנדרש, וכמובן לא שינינו קודקודים שנמצאים מחוץ לתת העץ שהתחיל ב- r, וזאת מאחר שהאלגוריתם תמיד "יורד למטה". כעת נוכיח את נכונות האלגוריתם. נטען טענה שקולה: בשלב ה- i של הריצה, הקודקודים + i,n n,, n הם שורשים של ערימות מקסימום. עבור = 0 k כל העלים הם ערימות מקסימום והטענה נכונה. נניח עבור k שהקודקודים + k,n n,, n הם שורשים של ערימות מקסימום. צעד האינדוקציה: אנו עובדים על

22 ר) הקודקוד ב-,A n k ונשים לב שהבנים שלו k) rigt n k, left(n הם שורשים של ערימות מקסימום ע"פ הנחת האינדוקציה, וזאת מאחר ש-.rigt n k > left n k > n k כלומר, לפי טענה 5 ג', לאחר הפעלת MAX HEAPIFY על קודקוד זה נקבל ערימת מקסימום תקינה, והשלמנו את האינדוקציה. כעת נותר רק לוודא שלא קילקלנו אף קודקוד אחר במהלך הפעלת האלגוריתם. נבחין בין שני מקרים: אם קודקוד n k < j n הוא בתת עץ של n k אזי לפי טענה 5 ב' הוא שורש של ערימת מקסימום ולכן הכל נשאר תקין. אם הקודקוד כנ"ל הוא לא בתת עץ של n, k אזי MAX HEAPIFY כלל לא משפיע עליו )כיוון שהוא "יורד למטה" בלבד(, ולכן הוא היה שורש של ערימת מקסימום )ע"פ הנחת האינדוקציה( ונשאר כזה. טענה 6: זמן הריצה של BUILD HEAP הוא.O(n) n הוכחה: בעץ בעל n קודקודים יש לכל היותר קודקודים המהווים שורש של תת עץ בגובה. זאת מאחר שבתת עץ הנ"ל לפחות קודקודים, וכל n הקודקודים של העץ מחולקים על פני עצים אלה. log n גבהים שונים בעץ )טענה n כעת אם נגדיר c כמחיר התיקון של עץ בגובה, יש לנו עצים כאלה, ויש 4(, נקבל: log n =0 c n cn =0 = cn = O n. ניתן להראות זאת למשל כיוון שזו נגזרת של טור: כדי לטעון שזה נכון חסרה לנו רק הוודאות שאכן = =0 =0 x = x x =0 = x x k =0 = x x k =0 = x x = x x = הערה: האלגוריתם עובר על כל קודקוד, ולכן הוא טריוויאלית,Ω(n) כלומר מתקבל שהוא.Θ(n) הערה: ניתן לממש ערימה גם באמצעות עץ בינארי אמיתי )עם מצביעים(, ללא מערך. הקושי הוא לדעת לאן להכניס איבר חדש למשל )או מאיפה לקחת איבר כשעושים,)EXTRACT MAX שכן אנו לא יכולים לגשת ישירות לאיבר האחרון של העץ בקלות. ניתן להתגבר על הבעיה הזאת באמצעות שמירת מצביע לאיבר האחרון בעץ יחד עם מבנה הערימה, או )באופן חסכוני יותר( החזקת מספר האיברים ברמה התחתונה של העץ. מסתבר שהייצוג הבינארי של מספר זה משקף בדיוק את המסלול לעלה האחרון, כאשר 0 מייצג פנייה שמאלה ו- פנייה ימינה. נשים לב שכיוון שהעץ הוא עץ בינארי כמעט שלם )לא עץ חיפוש כמובן(, הפעולות הן ב- O log n כמו שהיו לנו קודם. הערה: ניתן לממש ערימה גם באמצעות עץ חיפוש בינארי,)BST( למשל עץ ' AVL בהמשך(. במקרה זה, הערך המקסימלי בעץ נמצא בעומק O log n ולכן נרצה לשמור ולתחזק אותו לאחר כל פעולה על הערימה. כלומר, לאחר שמבצעים למשל,EXTRACT MAX נזכור לחפש את MAX(T) ולשמור אותו יחד עם הערימה )וכאשר מבצעים הכנסה, יש לבדוק האם האיבר שהוכנס גדול מהמקסימום הנוכחי(. באופן כזה אנו שומרים על ()O בזמן הריצה של MAX על הערימה, וגם שאר הפעולות לא נפגעות )למשל INCREASE KEY ניתן לממש

23 באמצעות מחיקה והוספה מחדש, ב- O(. log n הבעיה המרכזית עם שני המודלים הנ"ל היא פעולת,BUILD HEAP שכן הדרך הטובה ביותר לבנות עץ ממערך לא ממוין היא לבצע הכנסה n פעמים, והעלות כאן היא.Θ n log n מיון באמצעות ערימה Sort Heap ניתן להשתמש בערימה על מנת לבצע מיון של מערך place(.)in הרעיון הוא: נבנה ערימה מהמערך המקורי, וכעת נתחיל מהאיבר המקסימלי )השורש( ונחליף אותו עם האיבר שבסוף המערך. כעת נקטין את גודל הערימה ב-, ונבצע MAX HEAPIFY על השורש החדש. נחזור על התהליך עד שיישאר לנו איבר אחד, והמערך יהיה ממוין. HEAP SORT A, n BUILD HEAP A, n for i n downto swap A, A i decreent HEAPSIZE A MAX HEAPIFY A, כאן כמובן מתקבל זמן ריצה שהגורם הדומיננטי בו הוא ביצוע n פעמים,MAX HEAPIFY ולסיכום O n log n במקרה הגרוע )כמו.)MERGE SORT עץ חיפוש בינארי עץ חיפוש בינארי הוא מימוש של ADT המגדיר את הפעולות הבאות: (x - SEARCH(T, מבצע חיפוש של איבר עם מפתח מסוים במבנה MIN(T) - מחזיר את האיבר המינימלי במבנה MAX(T) - מחזיר את האיבר המקסימלי במבנה - SUCCESSOR,T x מחזיר את האיבר העוקב של איבר מסוים במבנה )מוגדר בתור האיבר המינימלי מבין האיברים הגדולים מ- x( (x - PREDECESSOR(T, מחזיר את האיבר הקודם של איבר מסוים במבנה )מוגדר בתור האיבר המקסימלי מבין האיברים הקטנים מ- x( אנו נממש עץ חיפוש בינארי Tree(,Binary Search או )BST באמצעות מצביעים, כאשר נשמור את שורש העץ root(t) ובכל קודקוד יהיו לנו המצביעים: rigt(x) parent x, left x, וכן את פעולת הגישה למפתח.key(x) היתרון במימוש של עץ באמצעות מצביעים על פני מערכים הוא שקל מאוד לעדכן מצביעים ואין צורך להקצות זיכרון מיותר רק עבור הקודקודים שהם אכן חלק מהעץ אנו מקצים זיכרון. הערה: בהמשך נניח לצורך הפשטות שהאיברים בעץ שונים זה מזה. עם זאת, ניתן להתמודד גם עם כפילויות ללא קושי. הגדרה: עץ חיפוש בינארי הוא עץ בינארי שבו לכל קודקוד x מתקיימת תכונת עץ חיפוש בינארי: לכל קודקוד y בתת עץ השמאלי של x, מתקיים key y < key x לכל קודקוד y בתת עץ הימני של x, מתקיים key(x) key y > מההגדרות בלבד, וללא שימוש בתוכן של האיברים בעץ, נוכל כבר בקלות לממש חלק מהפעולות:

24 MIN T l root T wile left l l left l return l MAX T r root T wile rigt r NIL r rigt r return r כלומר, בצורה הפשוטה ביותר, כדי למצוא את האיבר המינימלי הולכים בעץ שמאלה עד שנתקעים, וכדי למצוא את האיבר המקסימלי הולכים בעץ ימינה עד שנתקעים. על מנת לממש חיפוש של איבר בעץ, נעבור על העץ מהשורש ובכל פעם נקבל החלטה האם אנחנו צריכים ללכת ימינה או שמאלה לפי השוואת הערך שמחפשים עם הערך בקודקוד הנוכחי. ניתן לממש זאת בקלות ברקורסיה, אך גם הפתרון האיטרטיבי די פשוט. SEARCH T, x if T = NIL or key T = x ten return T if key T < x ten return SEARCH rigt T, x else return SEARCH left T, x כל הפונקציות שתיארנו בינתיים פועלות ב- O D כאשר D גובה העץ. במקרה שבו העץ הוא למעשה "שרוך" )כלומר שרשרת שבה אין לאף קודקוד יותר מבן אחד(, קיבלנו זמן חיפוש ליניארי - n O. בהמשך נראה מבנה דומה, עץ,AVL שבו על ידי ביצוע איזון מכוון הבעיה הזו נמנעת. כעת נתבונן במציאת איבר עוקב בעץ. הגדרה: העוקב של x הוא האיבר המינימלי מבין האיברים הגדולים מ-.succ x in {x T: x > x},x נבחין בין שלושה מקרים למציאת העוקב: אם x = ax T אזי אין לו עוקב.)NIL( אם ל- x יש בן ימני, אזי העוקב של x הוא המינימום של תת העץ הימני הזה:.succ x = in rigt y אם אין ל- x בן ימני, אזי אנו צריכים לעלות בעץ ולחפש את הפעם הראשונה שהמקום ממנו עלינו הוא הבן השמאלי של המקום אליו הגענו )כלומר עולים בעץ עד שפונים ימינה(....3 SUCCESSOR T, x if rigt x NIL return in rigt x y parent x wile y NIL and x = rigt y x y

25 y parent x return y טענה 7: האלגוריתם SUCCESSOR מחזיר תמיד את העוקב של x. הוכחה: המקרה הראשון ברור, אם x הוא המקסימום אזי אין לו עוקב. המקרה השני והשלישי פחות ברורים. במקרה השני, ל- x יש בן ימני. בקבוצת האיברים בתת העץ של x, כל האיברים הגדולים מ- x נמצאים ב- rigt x והמינימום מביניהם הוא אכן העוקב של x בתוך תת העץ שלו. אבל האם ייתכן שהעוקב נמצא מחוץ לתת העץ של x? טענה 7 א': )טענת הטווח( בעץ חיפוש בינארי, לכל תת עץ T, x כל האיברים שמחוץ ל- T x נמצאים מחוץ לטווח הערכים. MIN T x, MAX T x הוכחה: נבחר קודקוד מחוץ לתת העץ של x ונקרא לו z. נצייר את המסלולים מ- ) x MIN T x, MAX(T ו- z עד השורש של העץ, ונסמן ב- w את הקודקוד שבו יש פיצול )אם קיים כזה(. כעת נתבונן בשלושה מקרים: אם הפיצול ל- z הוא ימינה מהמסלול מהשורש ל- x, אזי z > w > MAX T x ולכן z מחוץ לטווח. אם הפיצול ל- z הוא שמאלה מהמסלול מהשורש ל- x, אזי z < w < MIN T x ולכן z מחוץ לטווח. אם z על המסלול מהשורש ל- x, אזי אם x נמצא בתת עץ השמאלי של z, מתקיים z, > MAX T x ואם x נמצא בתת עץ הימני של z אזי z < MIN T x ובשני המקרים הוא מחוץ לטווח. כעת מהטענה ברור שהעוקב נמצא בתת העץ הימני של x אם קיים כזה, כי אם הוא קיים, אזי בתת העץ הזה קיים איבר כלשהו הגדול מ- x, וכל האיברים מחוץ לתת העץ של x גדולים באיבר זה ולכן לא מקיימים את מינימליות העוקב. במקרה השלישי, ל- x אין בן ימני, וכעת למעשה תהליך חיפוש העוקב הוא בדיוק ההפך מלחפש את המקסימום בתת העץ השמאלי של העוקב שנמצא )נעלה למעלה עד שנפנה ימינה(. במקרה זה נסמן ב- y את הקודקוד שמצאנו ונתבונן בתת העץ שלו T. y בתוך תת עץ זה, ברור ש- y הוא העוקב של x שכן x = MAX left y )כדי להגיע מ- y ל- x פונים שמאלה ואז ימינה עד הסוף, שזה המקסימום(. כלומר, מתקבל ש- x הוא המקסימום של כל האיברים הקטנים מ- y, ולכן y הוא המינימום של כל האיברים הקטנים מ- x. מחוץ לתת העץ T y אין לנו בכלל טעם להסתכל כיוון שלא קיים ערך בין x לבין y הנמצא מחוץ ל- T, y על פי טענת הטווח. סיבוכיות זמן הריצה של SUCCESSOR היא שוב O(D) כיוון שבכל המקרים אנו מטפסים במסלול במעלה העץ או במורד העץ. טענה 8: הפעלת SUCCESSOR ברצף החל מהאיבר המינימלי בעץ ועד האיבר המקסימלי בעץ הוא אלגוריתם בסיבוכיות.O(n) TRAVERSE SUCCESSOR T y MIN T wile y NIL do y SUCCESSOR(T, y) הוכחה: האלגוריתם עובר פעמיים בדיוק על כל צלע בעץ, ולכן כמובן זמן הריצה שלו הוא.O(n) על מנת להוכיח זאת ניעזר בשתי טענות עזר:

26 טענה 8 א': עבור כל תת עץ בגובה, לאחר שהאלגוריתם נכנס אליו הוא עובר בדיוק פעמיים על כל צלע ויוצא מתת העץ. הוכחה: אינדוקציה על. הבסיס עבור = נכון. נניח עבור עצים בגובה ונוכיח עבור עצים בגובה +. כאשר האלגוריתם מגיע לשורש של עץ בגובה + בפעם הראשונה, הוא עושה זאת בדרך למטה. בין אם x הוא בן ימני או שמאלי, הכיוון הוא לחפש את המינימום בתת העץ של x, כלומר הולכים שמאלה ועוברים על הצלע } x,x} left בפעם הראשונה. לאחר שנסיים בתת העץ השמאלי של x נחזור שוב על הצלע בכיוון מעלה, כלומר על {x {left x, ובאופן דומה עבור } x,x}. rigt לפי טענה 8 ב' לא נחזור לעולם לתת העץ של x ולכן לא נעבור שוב על צלעות אלה. לכן על שתי צלעות אלה ביצענו בדיוק שני מעברים, ובכל צלע בתתי העצים השמאלי והימני של x בוודאי נעבור על כל צלע פעם אחת, מתוקף הנחת האינדוקציה. טענה 8 ב': לאחר שהאלגוריתם יצא מתת עץ בגובה הוא לא יחזור אליו לעולם. הוכחה: אינדוקציה על בסדר הפוך. בסיס H גובה העץ כולו, נכון באופן ריק כי לא ניתן לצאת מחוץ לשורש של העץ. עבור קודקוד,x x = האלגוריתם נכנס קודם כל לתת העץ השמאלי. בשלב מסוים האלגוריתם יוצא ממנו ומגיע ל-.x = SUCCESSOR MAX rigt x לאחר פעולת SUCCESSOR נוספת האלגוריתם יבקר בתת העץ הימני של x. כשחוזרים מתת העץ הימני, לא נעצור ב- x אלא נצא מתת העץ שלו ונגיע להורה של x. מהנחת האינדוקציה ) ) parent x > x = לא נחזור יותר ל- x ובפרט לא נחזור לכל תת העץ שלו. משתי הטענות יחד ברור שעוברים בדיוק פעמיים על כל צלע, כפי שרצינו. כעת נותרו לנו פעולות ההכנסה והמחיקה, שמבצעות שינויים בעץ. ההכנסה היא פעולה פשוטה יחסית נחפש את המקום שבו האיבר החדש צריך היה להיות אילו היינו מחפשים אותו, ושם נכניס אותו. כמובן, כל איבר חדש שנכנס לעץ הוא עלה )לא ניתן להכניס איברים ב"אמצע" העץ(. INSERT T, z y NIL x root T wile x NIL y x if key z < key x ten x left x else x rigt x if y = NIL ten root T z else if key z < key y ten left y z else rigt y z parent z y גם כאן סיבוכיות זמן הריצה של האלגוריתם היא פשוט( O(D כיוון שאנחנו מתקדמים במסלול יחיד במורד העץ. המחיקה היא פעולה עדינה יותר כאן נצטרך להבחין בין שלושה מקרים, כדי שלא לפגוע בתכונת ה- :BST אין לקודקוד בנים כלל. במקרה זה אפשר פשוט למחוק אותו ורק צריך לעדכן את ההורה שלו. יש לקודקוד בן אחד. במקרה זה ניתן לחבר את ההורה של הקודקוד לבן שלו )עוקפים את הקודקוד(. יש לקודקוד שני בנים. במקרה זה נדרשת העדינות המירבית. ניעזר בטענה 8:...3

27 טענה 9: אם ל- z שני בנים, לעוקב של z אין בן שמאלי. הוכחה: אם היה לעוקב של z שנסמנו s בן שמאלי שנסמנו s, אזי מתקיים s > s > z בסתירה להגדרת העוקב. )ניתן גם להתבונן במקרים הפרטיים של מציאת עוקב, כאן אנחנו במקרה השני של מציאת עוקב ואין לעוקב בן שמאלי כי אילו היה כזה, הוא היה in rigt z ולא העוקב עצמו.( כעת במקרה 3, לפי טענה 9, אפשר פשוט למחוק את העוקב של z מעץ ולהעביר אותו למקום שבו היה z )המחיקה לא מורכבת כי לעוקב יש לכל היותר בן אחד(, ועדיין נשמרת תכונת BST כי בין העוקב של איבר מסוים לבין האיבר הזה אין אף איבר אחר )לפי ההגדרה(. DELETE T, z if left z = NIL or rigt z = NIL cild left z if cild = NIL ten cild rigt z if z = left parent z ten left parent z cild else rigt parent z cild delete z else y SUCCESSOR T, z value z value y DELETE T, y וכאן במקרים, סיבוכיות זמן הריצה היא פשוט ()O אבל במקרה 3 אנו צריכים למצוא את העוקב, ולכן סיבוכיות זמן הריצה היא O(D) כמו ביתר הפעולות. ניתן להציע גם אלגוריתם אלטרנטיבי למחיקה מעץ חיפוש בינארי. אם יש ל- z שני ילדים, נחבר את תת העץ השמאלי שלו בתור תת העץ השמאלי של העוקב שלו, ואז נמחק את z )שכעת יש לו בן אחד בלבד(. האלגוריתם נראה כך: DELETE T, z if left z = NIL or rigt z = NIL do sae as above else y SUCCESSOR T, z left y left z DELETE(T, z) דבר שימושי נוסף שאפשר לשאול על עץ הוא מה הקוטר שלו מקסימום המרחקים בין כל שני קודקודים בעץ. אם ננסח את הבעיה אחרת, הפתרון יהיה ברור: הקוטר של העץ הוא למעשה המקסימום בין סכום הגבהים של תת העצים )ועוד עבור הצלעות לשורש(, לבין הקוטר של תת העץ השמאלי והקוטר של תת העץ הימני. מניסוח זה ברור הפתרון הרקורסיבי, בהינתן הגובה של כל קודקוד: DIAMETER x if x = NIL ten return 0 ld DIAMETER left x rd DIAMETER rigt x

28 lp eigt left x + eigt rigt x + return ax {ld, rd, lp} הערה: אם העץ מאוזן, התשובה יכולה להיות פשוטה יותר. למשל, בעץ AVL שבו מובטח שהפרש הגבהים בין תת העצים הוא לכל היותר, הקוטר הוא פשוט סכום הגבהים של תת העצים של השורש, פלוס. Order Statistics הגדרה: ה- order statistic ה- i בקבוצה } n {a,, a הוא האיבר ה- i בקבוצה } n {a,, a שבה מתקיים לכל j j < ש- a j < a j )כלומר זהו האיבר ה- i הקטן ביותר(. נרצה לפתור בעיה קטנה כיצד מוצאים את ה- order statistic ה- i במבנה מסוים? במערך ממוין זה לא קשה במיוחד, אם האיברים כולם שונים זה מזה אזי זו פעולה של( O(. בעץ חיפוש בינארי, לדוגמה, זו בעיה קשה יותר. פתרון נאיבי לדוגמה הוא למצוא את המינימום ואז לקרוא ל- SUCCESSOR במשך i פעמים. זה אמנם O(n) )לפי טענה 8( אבל ניתן לעשות משהו טוב יותר. הצעה ראשונה: בכל קודקוד נחזיק את ה- order statistic שלו. מציאת ה- OS ה- i היא אפוא פעולה ב- O(D) כאשר D גובה העץ. הבעיה המרכזית עם ההצעה הזאת היא התחזוקה מחיקה או הכנסה לעץ הופכות להיות פעולות מאוד מורכבות. הצעה שנייה: בכל קודקוד נחזיק את גודל תת העץ שלו )נקרא לו.)size כאשר מבצעים חיפוש, ניתן להסתכל על הגודל של הבן השמאלי כדי להבין האם צריך לחפש שם או בבן הימני : OS FIND root, i lsize 0 if left root NIL ten lsize size left root if lsize j ten return OS FIND left root, i if lsize + = i ten return root return OS FIND rigt root, i lsize נשים לב שעכשיו ההכנסה וההוצאה מהעץ הן פעולות יותר זולות, כי בכל פעולה כזו אנו לא מבצעים שינויים מחוץ למסלול לקודקוד שנמחק או הוכנס, ולכן קל לנו יחסית לשלוט על ה- size השמור בכל קודקוד. ניתן אף לשפר אותו ולשמור בכל קודקוד את הגודל של תת העץ השמאלי שלו שזה מה שאנחנו באמת משתמשים בו באלגוריתם. ניתן להשתמש בעץ שבו בכל קודקוד יש את גודל תת העץ שלו לצרכים נוספים, למשל לצורך מימוש האלגוריתם COUNT RANGE שבודק כמה קודקודים בעץ נמצאים בטווח [b,a] )כאשר הקצוות של הטווח לא בהכרח נמצאים בעץ(. COUNT RANGE T, a, b return COUNT BIGGER root T, a COUNT BIGGER root T, b COUNT BIGGER x, a if x = NIL ten return 0 if a key x ten return + size rigt x + COUNT BIGGER left x, a else return COUNT BIGGER rigt x, a

29 עצי AVL נשים לב שכל הפעולות שהגדרנו תלויות בגובה העץ אם גובה העץ ליניארי במספר האיברים, אזי קיבלנו מבנה מאוד לא יעיל המזכיר רשימה מקושרת. לחלופין, אם העץ הוא עץ שלם )או כמעט שלם(, אזי הפעולות לוגריתמיות במספר האיברים. אם כך, המטרה שלנו צריכה להיות לאזן את העץ להביא את העץ למצב שבו גובהו הוא ) n O(log עבור n קודקודים. n k קיימות הרבה דרכים לבנות עצים כאלה, ביניהן עצי -3-4, עצים אדומים-שחורים, וגם עצי AVL שיעסיקו אותנו. הגובה של עצים אלה הוא לוגריתמי במספר האיברים, מה שגורם לפעולות להיות מאוד מהירות. כמובן יש לזה מחיר איזון העץ תוך כדי ביצוע פעולות המשנות אותו )הכנסה ומחיקה( היא משימה שלוקחת זמן. הגדרה: עץ חיפוש בינארי הוא עץ AVL אם לכל קודקוד x מתקיים x, left x rigt כלומר ההבדל בגבהים של תת העץ השמאלי והימני לכל קודקוד הוא לכל היותר. הערה: חשוב לשים לב שתכונת AVL צריכה להתקיים בכל קודקוד, ולא רק בשורש. על מנת להרוויח מהשימוש ב-,AVL עלינו להוכיח שגובה העץ הוא אכן לוגריתמי. נסמן n k מספר הקודקודים המינימלי בעץ AVL בגובה k. טענה 0: עולה מונוטונית ב-,k כלומר.n k+ > n k הוכחה: נתבונן בעץ AVL בגובה + k שבו מספר הקודקודים הוא מינימלי. אחד מהבנים של השורש הוא עץ AVL בגובה k )אחרת גובה העץ לא היה + k(. בתת עץ זה שגובהו k יש בדיוק n k קודקודים )שכן אם יש בו יותר קודקודים, העץ כולו לא היה בעל מספר הקודקודים המינימלי בגובה + k, ואם יש בו פחות זו סתירה להגדרת n(. k לכן ברור ש- + k n +k n )בגלל השורש עצמו(, אבל כמובן כיוון שגם קיים תת עץ נוסף בגובה k או k )בפועל בהכרח בגובה k משיקולי מינימליות(, העלייה המונוטונית היא אפילו ביותר מ-. כעת אנו יכולים לכתוב נוסחת רקורסיה על מספר הקודקודים המינימלי: n k = n k + n k + הערה: משיקולי מינימליות, אחד מתת העצים של עץ AVL בעל מספר קודקודים מינימלי בגובה k הוא עץ AVL בעל מספר קודקודים מינימלי בגובה k, והשני בגובה k. לכן מתקבלת הנוסחה. על ידי הוספת לשני האגפים נוכל לקבל: n k + = n k + + n k + F k n k + F k = F k + F k והנוסחה האחרונה שקיבלנו היא בדיוק הנוסחה לאיברי סדרת פיבונאצ 'י. נוכל לחסום את n k בכמה דרכים. טענה : O() k log n + הוכחה: נשתמש במשוואת הרקורסיה המקורית ונוציא ממנה אי-שוויון משיקולי מונוטוניות )טענה 0(, ואז נשתמש בשיטת האיטרציה: n k = n k + n k +

30 n k > n k + > n k = n k > n k = 3 n k > > k n 0 + k כאשר כאן כמובן = 0 n )גודל עץ AVL המינימלי בגובה 0 קודקוד אחד(. לכן קיבלנו כאן סדרה הנדסית, n k > k + n k + > k + log n k + > k + log n k + > k k < log n k + log n k = log n k וסכומה = k +, לכן יש לנו: כלומר יש לנו ) k k log (n כמו שרצינו. )במקרה האי-זוגי מתקבל גם הגורם של ()O כפי שדרשנו בטענה.( כיוון שאנו יודעים ש- n k הוא מספר הקודקודים המינימלי בעץ בגובה k, ברור ש- k log n k log n כמו שרצינו. k.44 log n k + O )חסם הדוק יותר( טענה : הוכחה: ראינו את הקשר בין סדרת פיבונאצ'י לבין n, k בפרט 3+k,k. n k = F נשתמש בידוע לנו על מספרי פיבונאצ'י )את השוויון הראשון קל להראות באינדוקציה או ישירות ע"י התבוננות בפתרונות המשוואה הריבועית :)x = x + F n = 5 F n n n 5 = 5 n 5 n < לכן נוכל פשוט להציב: n k k+3 log n k k + 3 log + 5 k.44 log n k + O log 5 אנחנו מאוד מרוצים מגובה עץ,AVL וכעת נרצה לראות כיצד ניתן לתחזק את הגובה הזה כיצד ניתן לשמור על העץ מאוזן אבל עדיין לדאוג לכך שפעולות ההכנסה והמחיקה יישארו יעילות יחסית. הערה: כל הפעולות על עץ חיפוש בינארי שאינן משנות אותו )למשל חיפוש, מציאת עוקב וכד'( נכונות עדיין בעץ D. = O log n ובעלות אותה סיבוכיות, כאשר כעת אנו יודעים ש- AVL

31 על מנת לבצע את הבדיקה האם העץ עדיין מאוזן, ולעשות זאת בצורה יעילה, נשמור בכל קודקוד את הגובה שלו )גובה תת העץ שהוא השורש שלו(, כאשר נתייחס לגובה של תת עץ ריק בתור. נבצע את ההכנסה באופן רגיל, אך לאחר שהגענו למקום שבו ביצענו את ההכנסה, נטפס במעלה העץ ובכל קודקוד נעדכן את הגובה בהתאם. נשים לב שבמהלך ביצוע העדכונים הגבהים של תתי עצים שאינם נמצאים במסלול אל הקודקוד המוכנס בוודאי לא נפגעו, כלומר הפרת תכונת AVL )אחת או יותר( יכולה להתרחש רק בקודקודים בדרך מהשורש לקודקוד המוכנס. כאשר נזהה הפרה של תכונת AVL )כלומר נמצא קודקוד > x,)x left x rigt נרצה לתקן אותה באמצעות רוטציות של העץ. כמובן נרצה גם שהרוטציות ישמרו את תכונת ה- AVL ולא יפגעו בתת עצים אחרים, וכן שהשדה המחזיק את הגובה של הקודקוד יהיה נכון ומעודכן. נבחין בין ארבעה מקרים שונים באשר למוקד ההפרה. במקרה,LL זיהינו את ההפרה בקודקוד B, והקודקוד שהוכנס נמצא תחת הבן השמאלי )שיסומן A( L של תת הבן השמאלי של B )שיסומן A( לכן המקרה נקרא,LL כי יש ללכת פעמיים שמאלה מ- B כדי להגיע לתת העץ שבו בוצעה ההכנסה. כמו כן נסמן גם את הבן הימני של B ושל A באמצעות B R, A R בהתאמה. הטענה שיש לנו הפרה של תכונת AVL בקודקוד B משמעותה ש- > R. B L B הדבר המעניין הוא שאנחנו יכולים לקבוע באופן חד משמעי מה הגבהים היחסיים של העצים השונים שסימ נו קודם : נניח שלפני ההכנסה הגובה של A L היה. הגובה של A R יכול להיות +.,, בפועל, אם הגובה היה + אזי לא הייתה לנו הפרה לאחר ההכנסה )כי לכל היותר A L יכול להפוך להיות בגובה + (. באופן דומה, אם הגובה היה אזי לאחר ההכנסה ב- A L נקבל הפרה כבר ב- A )כי גובהו של A L הופך להיות + - אחרת לא הייתה לנו הפרה בכלל(, אבל אנו יודעים שההפרה היא רק ב- B. לכן בהכרח הגובה של A R הוא. לפני ההכנסה הגובה של A היה +, ולכן הגובה של B R יכול להיות +., +, רק המקרה ייתכן כי בשני המקרים האחרים )לאחר שהגובה של A הופך ל- + ( לא מתרחשת הפרה. כלומר הגובה של B R הוא. לסיכום, לאחר ביצוע ההכנסה הגבהים הם: A L = +, H A R =, H A = +, B R =, B = + 3 על מנת לתקן את המצב, נבצע רוטציית LL נתלה את העץ על הקודקוד A במקום על הקודקוד B, כך ש- B הופך להיות הבן הימני של A, הבן הימני של A הופך לבן השמאלי של B ו- A מחליף את B במקום שהוא היה: LL B A left B, A R rigt A left B A R rigt A B השמטנו כאן את הקוד המטפל ב- parent x עבור כל הקודקודים המעורבים, למען הקריאות. לאחר ביצוע הרוטציה, הפרת תכונת ה- AVL תוקנה כעת הגבהים הם: A = +, A L = +, B = +, A R =, A L = נשים לב גם שלא פגענו בתכונת ה-,BST כיוון שהרוטציה שומרת עליה. בפרט, כיוון ש- A היה בן שמאלי של B, אנחנו יכולים להפוך את B להיות הבן הימני של A )כל האברים בו גדולים מ- A(, וכן כיוון שהבן הימני של A נמצא